const os = require('os');
const path = require('path');

// 获取本机IP地址
function getLocalIP() {
  const interfaces = os.networkInterfaces();
  
  for (const name of Object.keys(interfaces)) {
    for (const iface of interfaces[name]) {
      // 跳过内部地址和非IPv4地址
      if (iface.family === 'IPv4' && !iface.internal) {
        return iface.address;
      }
    }
  }
  
  return 'localhost';
}

// 格式化文件大小
function formatFileSize(bytes) {
  if (bytes === 0) return '0 Bytes';
  
  const k = 1024;
  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
  const i = Math.floor(Math.log(bytes) / Math.log(k));
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
}

// 验证路径是否安全 - 增强版
function isValidPath(userPath) {
  // 检查是否包含危险的路径遍历字符
  if (userPath.includes('..')) {
    return false;
  }
  
  // 检查是否包含绝对路径字符
  if (userPath.startsWith('/') || userPath.includes(':')) {
    return false;
  }
  
  // 检查是否包含协议前缀
  if (userPath.includes('://')) {
    return false;
  }
  
  // 检查是否包含危险字符
  const dangerousChars = ['<', '>', '|', '?', '*', '\x00'];
  for (const char of dangerousChars) {
    if (userPath.includes(char)) {
      return false;
    }
  }
  
  // 检查控制字符
  for (let i = 0; i < userPath.length; i++) {
    const charCode = userPath.charCodeAt(i);
    if (charCode < 32 && charCode !== 9 && charCode !== 10 && charCode !== 13) {
      return false;
    }
  }
  
  return true;
}

// 安全路径检查 - 增强版
function validatePath(userPath) {
  if (!userPath) {
    return true; // 空路径是安全的
  }
  
  // 首先检查用户路径是否有效
  if (!isValidPath(userPath)) {
    return false;
  }
  
  // 清理路径，移除相对路径组件
  const cleanPath = path.normalize(userPath);
  
  // 检查各种路径遍历攻击模式
  if (cleanPath.startsWith('..') || 
      cleanPath.includes('../') ||
      cleanPath.includes('..\\') ||
      cleanPath.startsWith('/') ||
      cleanPath.includes('://')) {
    return false;
  }
  
  return true;
}

// 安全路径构建
function safePath(basePath, userPath) {
  if (!userPath) {
    return { path: basePath, safe: true };
  }
  
  // 验证路径安全性
  if (!validatePath(userPath)) {
    return { path: null, safe: false };
  }
  
  const fullPath = path.join(basePath, userPath);
  
  // 确保路径在基础目录内 - 双重检查
  const absBase = path.resolve(basePath);
  const absFull = path.resolve(fullPath);
  
  // 标准化路径分隔符
  const normalizedBase = path.normalize(absBase);
  const normalizedFull = path.normalize(absFull);
  
  // 确保完整路径确实在基础目录内
  if (!normalizedFull.startsWith(normalizedBase)) {
    return { path: null, safe: false };
  }
  
  // 额外检查：确保不是基础目录本身的父目录
  if (normalizedFull.length < normalizedBase.length) {
    return { path: null, safe: false };
  }
  
  return { path: fullPath, safe: true };
}

// 清理文件名，移除危险字符
function sanitizeFilename(filename) {
  // 如果文件名为空，返回默认名称
  if (!filename || filename.trim() === '') {
    return 'unnamed_file';
  }
  
  // 移除路径分隔符和相对路径组件
  let sanitized = filename.replace(/[/\\]/g, '_');
  sanitized = sanitized.replace(/\.\./g, '_');
  
  // 移除控制字符和其他危险字符
  sanitized = sanitized.replace(/[<>:"|?*\x00-\x1f\x7f]/g, '_');
  
  // 移除开头的点号(隐藏文件)和空格
  sanitized = sanitized.replace(/^[. ]+/, '');
  
  // 移除结尾的点号和空格
  sanitized = sanitized.replace(/[. ]+$/, '');
  
  // 如果清理后文件名为空，返回默认名称
  if (!sanitized || sanitized.trim() === '') {
    return 'unnamed_file';
  }
  
  // 限制文件名长度(Windows路径限制)
  if (sanitized.length > 255) {
    const ext = path.extname(sanitized);
    const base = sanitized.substring(0, 255 - ext.length);
    sanitized = base + ext;
  }
  
  return sanitized;
}

// 获取文件扩展名
function getFileExtension(filename) {
  return filename.split('.').pop().toLowerCase();
}

module.exports = {
  getLocalIP,
  formatFileSize,
  validatePath,
  isValidPath,
  safePath,
  sanitizeFilename,
  getFileExtension
}; 